Maybe also reference here that it's intended to be referenced into by the indices property.

Sure, makes sense. I've added the following in a new paragraph:

The {{domxref("XRVisibilityMaskChangeEvent.indices", "indices")}} array specifies the indices of the vertices array that should be drawn to display the currently visible part of the scene displayed in the XRView.

More detail required than that to allow readers to understand what is going on

If these are floats, then they are numbers, not "points" so my guess in https://github.com/mdn/content/pull/43975/changes#r3215903956 is completely wrong. But the comment is valid - a reader should be able to work out how this works.

Right, I've looked up some more information, adjusted the indices and vertices descriptions, and added a paragraph on how this actually works to the vertices page. I'm not 100% sure if I'm right, so it'd be good for @alcooper91 to check this over.

This enables performance improvements by allowing the browser to draw only the visible part of the updated view.

Er, users get events - browsers generate them. So I can see that a browser can enable performance improvements, but it isn't clear what the user is supposed to do with this event and why it is relevant.

More text added to explain relevance

See https://github.com/mdn/content/pull/43975/changes#r3215941539 - it isn't clear to me how this works, since events are handled by user code, but it talks about browser behaviour.

The required information to draw the update is contained in the {{domxref("XRVisibilityMaskChangeEvent")}} event object.

As I understand it the event is-a XRVisibilityMaskChangeEvent - this is an odd way to say that. Am I missing something?

I've tried shifting the explanation around a bit.

[mdn-linter] _{reported by reviewdog 🐶}

@chrisdavidmills This is getting there, but I am still unsure.

What this says is that "vertices is an array of coordinate values representing a visibility mask" and the "indices array specifies the array positions of the vertices "

1. From "vertices is an array of coordinate values representing a visibility mask" the implication is that the array defines the mask, so there doesn't seem to be any reason to need the indices array?
2. My "guess" is that vertices contains a whole lot of points in an array and but not all of them are used for the mask - you iterate through indicies to find which points are relevant and then use them to build a mask. But
   • That isn't what it says.
   • If it is true I'd like to know why you don't just have verticies array that only contains the verticies that are needed.
   • I'd like to know how the mask is constructed from the verticies. Are they just points joined in order, with the mask being the inner polygon? That then being the "mask in clip space"
3. The values are "x and y value pairs representing points". However a Float32Array is a flat array - i.e. it is a list of floats, not "inherently" a list of float pairs. So are we saying that each point is two elements in this array, x, followed by y.

An example in this page would not hurt.

Ah looking at your example in the interface page, I think they are encoded as x,y in order. Gemini seems to think that the points are interpretted as groups of triangles, which would imply that you must have a certain number of points to always divide cleanly by three.
If that's true, all needs to be captured.

so there doesn't seem to be any reason to need the indices array?

I don't know why this approach is used. I wondered about this as well. Maybe @alcooper91 can provide an answer here.

So are we saying that each point is two elements in this array, x, followed by y.

Yes, I believe so. And the z-axis value in each case is a constant value.

Yes the Z is implied to be a constant value. You do need the indices array. It’s a common graphics tactic for encoding a mesh. Say the region is square.
vertices may be (groupings solely for the purpose of legibility in this discussion):
(0,0),(0,1),(1,1),(1,0)
With indices being: 0,1,2, 0,3,2

obviously for the simple square all the points could just define a polygon; but it’s meant to allow you to just pass the values to a graphics library. The indices should be a multiple of 3 representing the triangles used to build the mesh.

This and vertices may be sufficient here, but I won't know until https://github.com/mdn/content/pull/43975/changes#r3245058413 is clarified

No. All three are needed. You need to know the view the mesh is applied to and then the vertices and indices define the triangles that make up the mesh. It’s a common graphics idiom.

This could probably use some words. IN particular this looks like it is creating a three dimensional structure from the 2D point information in event.vertices - but I am not sure why?

Per my other comment you need to iterate through the indices array. Not just increment your own indices.

@toji can help me out here, there MAY be a WebGL or other structure you can basically just pass them into

This code is using Three.js, which (as far as I can tell) requires the 'position' attribute of a BufferGeometry to be a packed array of 3D points. So this type of conversion would be necessary.

With raw WebGL there's no specific requirement for the number of elements in an attribute, as the developer interprets it in the shaders. So there are scenarios where you could pass the event.vertices array in directly, just not with Three.js

Oh, just realized I probably read Alex's question wrong.

geometry.setIndex(new BufferAttribute(event.indices, 1)); as shown here is fine, because the indices are a Uint32Array and thus are already in the right format.